{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "initial_id",
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-20T13:09:03.091757Z",
     "start_time": "2024-09-20T13:05:54.829723Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from datetime import date\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "off_train_data = pd.read_csv('F:\\Demopython\\o2o\\O2O优惠券使用新人赛\\ccf_offline_stage1_train.csv', encoding='utf-8')\n",
    "off_test_data = pd.read_csv('F:\\Demopython\\o2o\\O2O优惠券使用新人赛\\ccf_offline_stage1_test_revised.csv',\n",
    "                            encoding='utf-8')\n",
    "off_train_data.head(5)\n",
    "off_test_data.head(5)\n",
    "# 填充缺失值\n",
    "off_train_data = off_train_data.fillna('null')\n",
    "off_test_data = off_test_data.fillna('null')\n",
    "\n",
    "\n",
    "# 用label列标记分类，label的取值为1表示正样本，0表示负样本，-1表示普通用户\n",
    "def label(row):\n",
    "    if row['Date'] != 'null' and row['Date_received'] != 'null':\n",
    "        if row['Coupon_id'] != 'null':\n",
    "            # 优惠券id不为空，表示使用了优惠券购买\n",
    "            # 计算使用优惠券的日期差值\n",
    "            td = pd.to_datetime(row['Date'], format='%Y%m%d') - \\\n",
    "                 pd.to_datetime(row['Date_received'], format='%Y%m%d')\n",
    "            if td <= pd.Timedelta(15, 'D'):  # 判断使用优惠券是否在15天内\n",
    "                return 1\n",
    "            else:\n",
    "                return 0\n",
    "        else:\n",
    "            # 其他情况：优惠券id为null，表示没有使用优惠券购买\n",
    "            return 0\n",
    "    if row['Date'] == 'null' and row['Date_received'] != 'null':\n",
    "        return 0\n",
    "    else:\n",
    "        return -1\n",
    "\n",
    "\n",
    "#对lable分类\n",
    "off_train_data['label'] = off_train_data.apply(label, axis=1)\n",
    "off_train_data['label'].value_counts()\n",
    "off_train_data.columns\n",
    "X = off_train_data.loc[:, off_train_data.columns != 'label']  # 数据\n",
    "y = off_train_data.loc[:, off_train_data.columns == 'label']  # 标签\n",
    "\n",
    "# 获取类1标签的长度\n",
    "count_one_Class = len(off_train_data[off_train_data['label'] == 1])\n",
    "\n",
    "# 获取两类标签的索引\n",
    "one_Class_index = off_train_data[off_train_data['label'] == 1].index\n",
    "zero_Class_index = off_train_data[off_train_data['label'] == 0].index\n",
    "\n",
    "# 随机选择相同数目的索引\n",
    "np.random.seed(100)  # 定义随机种子\n",
    "random_zero_index = np.array(np.random.choice(zero_Class_index, count_one_Class, replace=True))\n",
    "\n",
    "# 合并模型样本索引\n",
    "sample = np.concatenate([one_Class_index, random_zero_index])\n",
    "\n",
    "# 按照索引获取行\n",
    "off_train_data = off_train_data.loc[sample, :]\n",
    "# 打印结果对比\n",
    "print('label为1的数目：', len(one_Class_index))\n",
    "print('label为0的数目：', len(zero_Class_index))\n",
    "print('总数：', len(one_Class_index) + len(zero_Class_index))\n",
    "print('抽样label为1的数目：', len(one_Class_index))\n",
    "print('随机抽取label为0的数目：', len(random_zero_index))\n",
    "print('抽样总数：', len(one_Class_index) + len(random_zero_index))\n",
    "print('总样本形状：', off_train_data.shape)\n",
    "\n",
    "# 探索性分析\n",
    "print(off_test_data.columns)\n",
    "# 变换距离的类型，缺失值替换为-1\n",
    "off_train_data['Distance'] = off_train_data['Distance'].replace('null', -1).astype(int)\n",
    "off_test_data['Distance'] = off_test_data['Distance'].replace('null', -1).astype(int)\n",
    "print('查看缺失值结果：\\n', off_train_data.isnull().sum())\n",
    "# 描述性统计分析\n",
    "description = off_train_data.describe()\n",
    "# 依次计算极差值、系数、四分位数间距\n",
    "description.loc['range'] = description.loc['max'] - description.loc['min']\n",
    "description.loc['var'] = description.loc['std'] - description.loc['mean']\n",
    "description.loc['dis'] = description.loc['75%'] - description.loc['25%']\n",
    "print('描述性统计结果：\\n', np.round(description, 2))  # 保留两位小数\n",
    "\n",
    "# 检查所有其他列，确保它们都是数值类型\n",
    "for col in off_train_data.columns:\n",
    "    off_train_data[col] = pd.to_numeric(off_train_data[col], errors='coerce').fillna(-1)\n",
    "# 相关性分析\n",
    "corr = off_train_data.corr(method='pearson')  # 计算相关系数矩阵\n",
    "# 处理 'Distance' 列，确保它是数值类型\n",
    "off_train_data['Distance'] = pd.to_numeric(off_train_data['Distance'], errors='coerce').fillna(-1)\n",
    "print('相关系数矩阵为：\\n', np.round(corr, 2))\n",
    "# 绘制相关性热力图\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "plt.rcParams['font.sans-serif'] = 'SimHei'\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "plt.subplots(figsize=(10, 10))  # 设置画面大小\n",
    "sns.heatmap(corr, annot=True, vmax=1, square=True, cmap=\"Blues\")\n",
    "plt.title('相关性热力图')\n",
    "plt.show()\n",
    "# 箱型图\n",
    "off_train_data['Distance'].isnull().sum()\n",
    "off_test_data['Distance'].isnull().sum()\n",
    "D1 = np.array(off_train_data['Distance'].values)\n",
    "D2 = np.array(off_test_data['Distance'].values)\n",
    "plt.boxplot([D1, D2], labels=('off_train_data', 'off_test_data'))\n",
    "plt.title('距离箱型图')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "# 定义函数处理折扣率\n",
    "def convertRate(row):\n",
    "    if row == 'null':\n",
    "        return 1.0\n",
    "    elif ':' in str(row):\n",
    "        rows = row.split(':')\n",
    "        return 1.0 - float(rows[1]) / float(rows[0])\n",
    "    else:\n",
    "        return float(row)\n",
    "\n",
    "\n",
    "def getDiscountType(row):\n",
    "    # 如果 row 是浮点数，直接返回一个默认值或根据你的逻辑返回一个值\n",
    "    if isinstance(row, float):\n",
    "        return -1  # 或者其他表示非折扣类型的值\n",
    "    # 如果 row 是字符串，继续进行判断\n",
    "    elif ':' in row:\n",
    "        # 满多少减多少\n",
    "        return 1\n",
    "    else:\n",
    "        # 折扣率\n",
    "        return 0\n",
    "\n",
    "\n",
    "# 定义函数处理满减类型的折扣优惠券\n",
    "def Man_Rate(row):\n",
    "    if row == -1:\n",
    "        return 0\n",
    "    elif ':' in str(row):\n",
    "        rows = row.split(':')\n",
    "        return int(rows[0])\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "\n",
    "def Jian_Rate(row):\n",
    "    if row == -1:\n",
    "        return 0\n",
    "    elif ':' in str(row):\n",
    "        rows = row.split(':')\n",
    "        return int(rows[1])\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "\n",
    "# 调用函数构建跟折扣率相关的四个特征属性\n",
    "off_train_data['Dis_rate'] = off_train_data['Discount_rate'].apply(convertRate)\n",
    "off_train_data['Discount_type'] = off_train_data['Discount_rate'].apply(getDiscountType)\n",
    "off_train_data['Discount_man'] = off_train_data['Discount_rate'].apply(Man_Rate)\n",
    "off_train_data['Discount_jian'] = off_train_data['Discount_rate'].apply(Jian_Rate)\n",
    "off_test_data['Dis_rate'] = off_test_data['Discount_rate'].apply(convertRate)\n",
    "off_test_data['Discount_type'] = off_test_data['Discount_rate'].apply(getDiscountType)\n",
    "off_test_data['Discount_man'] = off_test_data['Discount_rate'].apply(Man_Rate)\n",
    "off_test_data['Discount_jian'] = off_test_data['Discount_rate'].apply(Jian_Rate)\n",
    "# 根据label标签来提取正、负样本的全部数据\n",
    "data = off_train_data[off_train_data['label'] != -1]\n",
    "data = data.fillna(-1)\n",
    "data['label'].value_counts()\n",
    "\n",
    "\n",
    "# 获取领券日期是星期几，并且构建成特征\n",
    "def getWeekday(row):\n",
    "    if row == 'null':\n",
    "        return row\n",
    "    else:\n",
    "        return date(int(row[0:4]), int(row[4:6]), int(row[6:8])).weekday() + 1\n",
    "\n",
    "\n",
    "data['Weekday'] = data['Date_received'].astype(str).apply(getWeekday)\n",
    "off_test_data['Weekday'] = off_test_data['Date_received'].astype(str).apply(getWeekday)\n",
    "# 周六日为类型1，其他为0\n",
    "data['Is_weekend'] = data['Weekday'].apply(lambda x: 1 if x in [6, 7] else 0)\n",
    "off_test_data['Is_weekend'] = off_test_data['Weekday'].apply(lambda x: 1 if x in [6, 7] else 0)\n",
    "\n",
    "\n",
    "# 跟星期相关的独热编码\n",
    "def One_hot(df):\n",
    "    weekdaycols = ['weekday' + str(i) for i in range(1, 8)]\n",
    "    tmpdf = pd.get_dummies(df['Weekday'].replace('null', np.nan))\n",
    "    tmpdf.columns = weekdaycols\n",
    "    df[weekdaycols] = tmpdf\n",
    "    return df\n",
    "\n",
    "\n",
    "data = One_hot(data)\n",
    "off_test_data = One_hot(off_test_data)\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "def func(data):\n",
    "    # 提取用户使用的优惠券的数量\n",
    "    f = data[['User_id', 'Coupon_id']].copy()  # 创建一个副本以避免警告\n",
    "    f['rec_coupon'] = 1\n",
    "    f = f.groupby(['User_id']).agg('sum').reset_index()\n",
    "\n",
    "    # 全部优惠券的数目\n",
    "    f1 = data[['Coupon_id']].copy()  # 创建一个副本以避免警告\n",
    "    l1 = len(f1)\n",
    "    f1['Number_coupon'] = 1\n",
    "    f1 = f1.groupby(['Coupon_id']).agg('sum').reset_index()\n",
    "    # 优惠券的流行度：每一种优惠券占全部优惠券的比例\n",
    "    f1['Coupon_popu'] = f1['Number_coupon'] / l1\n",
    "\n",
    "    # 提取用户和商家\n",
    "    f2 = data[['User_id', 'Merchant_id']].copy()  # 创建一个副本以避免警告\n",
    "    l2 = len(f2)\n",
    "    # 提取顾客去商家的数量\n",
    "    f2['Number_merchant'] = 1\n",
    "    f2 = f2.groupby(['Merchant_id']).agg('sum').reset_index()\n",
    "    # 商家的受欢迎度：商家的顾客（用户）占全部商家的顾客（用户）的比例\n",
    "    f2['Merchant_popu'] = f2['Number_merchant'] / l2\n",
    "\n",
    "    # 合并特征属性\n",
    "    d0 = pd.merge(data, f[['User_id', 'rec_coupon']], on='User_id')\n",
    "    d1 = pd.merge(d0, f1[['Coupon_id', 'Coupon_popu']], on='Coupon_id')\n",
    "    d2 = pd.merge(d1, f2[['Merchant_id', 'Merchant_popu']], on='Merchant_id')\n",
    "\n",
    "    return d2\n",
    "\n",
    "\n",
    "# 调用以上函数构建相关的三个特征属性\n",
    "new_data = func(data)\n",
    "new_test_data = func(off_test_data)\n",
    "\n",
    "\n",
    "# 定义函数得到跟距离相关的特征属性\n",
    "def Get_mer_dis(new_data):\n",
    "    # 查看距离的类别数量\n",
    "    new_data['Distance'].value_counts()\n",
    "    # 提取用户-商家距离的数据集\n",
    "    md1 = new_data[new_data.Coupon_id != 'null'][['Merchant_id', 'Distance']]\n",
    "    md1.replace('null', -1, inplace=True)\n",
    "    md1.replace(-1, np.nan, inplace=True)\n",
    "    # 用户-商家的距离最小值\n",
    "    md2 = md1.groupby('Merchant_id').agg('min').reset_index()\n",
    "    md2.rename(columns={'Distance': 'merchant_min_distance'}, inplace=True)\n",
    "    # 用户-商家的距离最大值\n",
    "    md3 = md1.groupby('Merchant_id').agg('max').reset_index()\n",
    "    md3.rename(columns={'Distance': 'merchant_max_distance'}, inplace=True)\n",
    "    # 用户-商品的距离平均值\n",
    "    md4 = md1.groupby('Merchant_id').agg('mean').reset_index()\n",
    "    md4.rename(columns={'Distance': 'merchant_mean_distance'}, inplace=True)\n",
    "    # 用户-离商品的距离中位值\n",
    "    md5 = md1.groupby('Merchant_id').agg('median').reset_index()\n",
    "    md5.rename(columns={'Distance': 'merchant_median_distance'}, inplace=True)\n",
    "    # 将所有特征合并在一起\n",
    "    merchant_feature = pd.merge(md2, md3, on='Merchant_id', how='left')\n",
    "    merchant_feature = pd.merge(merchant_feature, md4, on='Merchant_id', how='left')\n",
    "    merchant_feature = pd.merge(merchant_feature, md5, on='Merchant_id', how='left')\n",
    "    new_data = pd.merge(new_data, merchant_feature, on='Merchant_id', how='left')\n",
    "    return new_data\n",
    "\n",
    "\n",
    "# 调用上边函数构建距离相关的特征属性\n",
    "new_data = Get_mer_dis(new_data)\n",
    "new_test_data = Get_mer_dis(new_test_data)\n",
    "\n",
    "# 距离柱状图\n",
    "x = np.arange(-1, 11)\n",
    "dis1 = np.array(new_data['Distance'].value_counts().sort_index())\n",
    "dis2 = np.array(new_test_data['Distance'].value_counts().sort_index())\n",
    "plt.bar(x, dis1, tick_label=x, label='off_train_data', width=0.3)\n",
    "plt.bar(x + 0.3, dis2, label='off_test_data', width=0.3)\n",
    "plt.xlabel('距离')\n",
    "plt.ylabel('计数')\n",
    "plt.title('距离计数分布情况')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "\n",
    "# 定义变换距离类型的函数\n",
    "def get_distance_type(row):\n",
    "    # 距离未知\n",
    "    if row == -1:\n",
    "        return -1\n",
    "    # 1千米内\n",
    "    elif row >= 0 and row <= 2:\n",
    "        return 0\n",
    "    # 1.5-2.5千米内\n",
    "    elif row >= 3 and row <= 5:\n",
    "        return 1\n",
    "    # 3-4.5千米内\n",
    "    elif row >= 6 and row <= 9:\n",
    "        return 2\n",
    "    # 5千米\n",
    "    elif row == 10:\n",
    "        return 3\n",
    "    # 构建距离类型的特征属性\n",
    "\n",
    "\n",
    "new_data['Distance_type'] = new_data['Distance'].apply(get_distance_type)\n",
    "new_test_data['Distance_type'] = new_test_data['Distance'].apply(get_distance_type)\n",
    "# 新距离类型分布情况\n",
    "new_data['Distance_type'].value_counts()\n",
    "new_test_data['Distance_type'].value_counts()\n",
    "\n",
    "# 距离柱状图\n",
    "x1 = np.arange(-1, 4)\n",
    "dis_type1 = np.array(new_data['Distance_type'].value_counts().sort_index())\n",
    "dis_type2 = np.array(new_test_data['Distance_type'].value_counts().sort_index())\n",
    "plt.bar(x1, dis_type1, tick_label=x1, label='off_train_data', width=0.3)\n",
    "plt.bar(x1 + 0.3, dis_type2, label='off_test_data', width=0.3)\n",
    "plt.xlabel('距离类型')\n",
    "plt.ylabel('计数')\n",
    "plt.title('距离类型计数分布情况')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# 跟距离相关的独热编码\n",
    "def Get_dis_hot(df):\n",
    "    discols = ['Distance' + str(i) for i in range(-1, 11)]\n",
    "    tmpdf = pd.get_dummies(df['Distance'].replace('null', np.nan))\n",
    "    tmpdf.columns = discols\n",
    "    df[discols] = tmpdf\n",
    "    return df\n",
    "\n",
    "\n",
    "new_data = Get_dis_hot(new_data)\n",
    "new_test_data = Get_dis_hot(new_test_data)\n",
    "# 集成新的数据集后，对缺失值处理\n",
    "new_data = new_data.fillna(-1)\n",
    "new_test_data = new_test_data.fillna(-1)\n",
    "new_data.isnull().sum()\n",
    "new_test_data.isnull().sum()\n",
    "# 查看属性特征\n",
    "new_data.columns\n",
    "new_test_data.columns\n",
    "features = ['Dis_rate', 'Discount_type', 'Discount_man', 'Discount_jian',\n",
    "            'Distance', 'Distance_type', 'Distance-1', 'Distance0',\n",
    "            'Distance1', 'Distance2', 'Distance3', 'Distance4', 'Distance5',\n",
    "            'Distance6', 'Distance7', 'Distance8', 'Distance9', 'Distance10',\n",
    "            'rec_coupon', 'Coupon_popu', 'Merchant_popu', 'merchant_min_distance',\n",
    "            'merchant_max_distance', 'merchant_mean_distance', 'merchant_median_distance',\n",
    "            'Is_weekend', 'Weekday', 'weekday1', 'weekday2', 'weekday3', 'weekday4',\n",
    "            'weekday5', 'weekday6', 'weekday7']\n",
    "# 提取指定特征属性的数据集，并且划分为训练集和验证集\n",
    "X = new_data[features]\n",
    "y = new_data['label']\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y)\n",
    "# 进行网格搜索调参\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "param_second_grid = {\n",
    "     'learning_rate':[0.1,0.11,0.12,0.13],\n",
    "     'max_depth': [4],\n",
    "     'n_estimators': [160]\n",
    "}\n",
    "grid_second_search = GridSearchCV(estimator = GradientBoostingClassifier(),param_grid = param_second_grid, scoring = 'neg_mean_absolute_error', cv = 3)\n",
    "\n",
    "grid_second_search.fit(X_train , y_train)\n",
    "grid_second_search.best_params_\n",
    "# 导入Xgboost库\n",
    "import xgboost as xgb\n",
    "# 导入决策树相关的库\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "# 设置决策树的参数\n",
    "tree_params = {\n",
    "    'criterion': 'gini',  # 不纯度衡量标准\n",
    "    'max_depth': None,  # 树的最大深度\n",
    "    'min_samples_split': 2,  # 内部节点再划分所需的最小样本数\n",
    "    'min_samples_leaf': 1,  # 叶子节点最少样本数\n",
    "    'max_features': 'auto',  # 分裂时考虑的最大特征数\n",
    "}\n",
    "\n",
    "# 创建决策树分类器\n",
    "tree_clf = DecisionTreeClassifier(**tree_params)\n",
    "\n",
    "# 使用训练数据训练决策树模型\n",
    "tree_clf.fit(X_train, y_train)\n",
    "\n",
    "# 在验证集上进行预测\n",
    "y_predict_tree = tree_clf.predict(X_test)\n",
    "\n",
    "# 计算AUC值\n",
    "tree_auc = roc_auc_score(y_test, y_predict_tree)\n",
    "print(\"决策树模型的AUC值：\", tree_auc)\n",
    "\n",
    "# 绘制ROC曲线\n",
    "from sklearn import metrics\n",
    "import matplotlib.pyplot as plt\n",
    "axline = np.array([0.,0.2,0.4,0.6,0.8,1.0])  # 斜线参考线坐标\n",
    "# 绘制ROC曲线\n",
    "fpr_tree, tpr_tree, thresholds_tree = metrics.roc_curve(y_test, y_predict_tree, pos_label=1)\n",
    "roc_auc_tree = metrics.auc(fpr_tree, tpr_tree)  # auc为Roc曲线下的面积\n",
    "plt.plot(fpr_tree, tpr_tree, 'b')  # 绘制ROC曲线\n",
    "plt.plot(axline, axline, 'gray', linestyle='--', alpha=0.5)\n",
    "plt.grid(axis='both', alpha=0.3)\n",
    "plt.xlim([-0.05, 1.05])\n",
    "plt.ylim([-0.05, 1.05])\n",
    "plt.xlabel('FPR')\n",
    "plt.ylabel('TPR')\n",
    "plt.title('AUC = %0.2f' % roc_auc_tree)\n",
    "plt.show()\n",
    "\n",
    "# 使用训练好的模型对测试数据进行预测\n",
    "pre_test_features = new_test_data[features]\n",
    "test_result_tree = tree_clf.predict_proba(pre_test_features)[:, 1]  # 获取正类的预测概率\n",
    "test_result = new_test_data[['User_id', 'Coupon_id', 'Date_received']]\n",
    "test_result['Probability'] = test_result_tree\n",
    "test_result.to_csv('./new_sample_submission_tree.csv', index=None, header=None)"
   ],
   "id": "bdaca8c476a2ceb1",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label为1的数目： 64395\n",
      "label为0的数目： 988887\n",
      "总数： 1053282\n",
      "抽样label为1的数目： 64395\n",
      "随机抽取label为0的数目： 64395\n",
      "抽样总数： 128790\n",
      "总样本形状： (128790, 8)\n",
      "Index(['User_id', 'Merchant_id', 'Coupon_id', 'Discount_rate', 'Distance',\n",
      "       'Date_received'],\n",
      "      dtype='object')\n",
      "查看缺失值结果：\n",
      " User_id          0\n",
      "Merchant_id      0\n",
      "Coupon_id        0\n",
      "Discount_rate    0\n",
      "Distance         0\n",
      "Date_received    0\n",
      "Date             0\n",
      "label            0\n",
      "dtype: int64\n",
      "描述性统计结果：\n",
      "           User_id  Merchant_id   Distance     label\n",
      "count   128790.00    128790.00  128790.00  128790.0\n",
      "mean   3692702.53      4089.66       1.85       0.5\n",
      "std    2123054.73      2470.94       3.35       0.5\n",
      "min         35.00         2.00      -1.00       0.0\n",
      "25%    1851861.25      1945.00       0.00       0.0\n",
      "50%    3687889.00      3621.00       0.00       0.5\n",
      "75%    5536347.00      6434.00       2.00       1.0\n",
      "max    7360941.00      8856.00      10.00       1.0\n",
      "range  7360906.00      8854.00      11.00       1.0\n",
      "var   -1569647.81     -1618.73       1.50       0.0\n",
      "dis    3684485.75      4489.00       2.00       1.0\n",
      "相关系数矩阵为：\n",
      "                User_id  Merchant_id  Coupon_id  Discount_rate  Distance  \\\n",
      "User_id           1.00         0.00      -0.00           0.01     -0.00   \n",
      "Merchant_id       0.00         1.00       0.03           0.03     -0.00   \n",
      "Coupon_id        -0.00         0.03       1.00           0.03      0.03   \n",
      "Discount_rate     0.01         0.03       0.03           1.00     -0.03   \n",
      "Distance         -0.00        -0.00       0.03          -0.03      1.00   \n",
      "Date_received     0.00        -0.05      -0.10          -0.04     -0.21   \n",
      "Date              0.00         0.06       0.03           0.07     -0.33   \n",
      "label             0.01         0.06       0.03           0.07     -0.33   \n",
      "\n",
      "               Date_received  Date  label  \n",
      "User_id                 0.00  0.00   0.01  \n",
      "Merchant_id            -0.05  0.06   0.06  \n",
      "Coupon_id              -0.10  0.03   0.03  \n",
      "Discount_rate          -0.04  0.07   0.07  \n",
      "Distance               -0.21 -0.33  -0.33  \n",
      "Date_received           1.00  0.22   0.22  \n",
      "Date                    0.22  1.00   0.99  \n",
      "label                   0.22  0.99   1.00  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "F:\\anaconda\\Lib\\site-packages\\sklearn\\tree\\_classes.py:269: FutureWarning: `max_features='auto'` has been deprecated in 1.1 and will be removed in 1.3. To keep the past behaviour, explicitly set `max_features='sqrt'`.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "决策树模型的AUC值： 0.7672955974842767\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Li\\AppData\\Local\\Temp\\ipykernel_13240\\3831186575.py:412: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  test_result['Probability'] = test_result_tree\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "",
   "id": "f87aa2670c7ca69a"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
